package com.limao.CacheManager;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.SortedMap;
import java.util.TreeMap;

import javax.servlet.AsyncContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.Aliyun.alipay.config.AlipayConfig;
import com.Aliyun.alipay.pay.alipay_ask_DataClass;
import com.Aliyun.alipay.pay.alipay_ask_Provider;
import com.Aliyun.alipay.sign.RSA;
import com.Aliyun.alipay.util.AlipayCore;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.corefire.config.CorefireConfig;
import com.corefire.util.CorefireHttpPost;
import com.corefire.util.MD5;
import com.corefire.util.SignUtils;
import com.corefire.util.XmlUtils;
import com.iapppay.android.OrderForAndroid;
import com.iapppay.ios.OrderForIos;
import com.iapppay.sign.IappayData;
import com.iapppay.sign.SignHelper;
import com.iapppay.web.OrderForWeb;
import com.limao.DBDataClass.CrowdOrderDataClass;
import com.limao.DBDataClass.CrowdSysProjectClass;
import com.limao.DBDataClass.CrowdUserAuthClass;
import com.limao.DBProvider.CrowdOrderProvider;
import com.limao.Model.LzPluginException;
import com.limao.Model.PublicData;
import com.limao.Model.RecvData;
import com.limao.Tencent.tenpay.ResponseHandler;
import com.limao.Tencent.tenpay.pay.TenpayConfig;
import com.limao.Tencent.tenpay.pay.Tenpay_ask_DataClass;
import com.limao.Tencent.tenpay.pay.Tenpay_ask_Provider;
import com.limao.Tool.CacheClass;
import com.limao.Utils.OrderPayParm;
import com.limao.Utils.OutPrintClass;
import com.limao.dataEnum.OnlinePayEnum;
import com.limao.dataEnum.OrderStateEnum;
import com.unionpay.acp.demo.DemoBase;
import com.unionpay.acp.sdk.AcpService;
import com.unionpay.acp.sdk.LogUtil;
import com.unionpay.acp.sdk.SDKConfig;


public class OrderInfo {

	
	//新鲜宝 生成订单
	public static Object resultSYSAddOrder_ByShopcart(HttpServletRequest request,HttpServletResponse response,AsyncContext asyncContext,int m,RecvData DataObj) throws Exception
	{
		
		// 参数检查
		if (CacheClass.isEmpty(DataObj.projectid) || CacheClass.isEmpty(DataObj.num)
				|| CacheClass.isEmpty(DataObj.paytype) 
				|| CacheClass.isEmpty(DataObj.apptype)	|| CacheClass.isEmpty(DataObj.address) || CacheClass.isEmpty(DataObj.shengid) || CacheClass.isEmpty(DataObj.cityid))
		{
			throw new LzPluginException("内容为空或者参数不正确");
		}
		char r = 10; 
		char n = 13; 
		char s=32;
		
		DataObj.address=DataObj.address.replace(r, s);
		DataObj.address=DataObj.address.replace(n, s);
		
		
		int userid = CacheClass.getIntValue(DataObj.userid);
		if (userid == 0) {
			throw new LzPluginException("没有登录不能操作");
		}

		int paytype = CacheClass.getIntValue(DataObj.paytype);
		/*  apptype 0:网页   1:android  2:ios */
		int apptype = CacheClass.getIntValue(DataObj.apptype);

		
		int alipayType=CacheClass.getIntValue(BaseDataCacheManager.getInstance().Load_Param("alipayType").trim());
		int alipayforandroid=CacheClass.getIntValue(BaseDataCacheManager.getInstance().Load_Param("alipayforandroid").trim());
		if(alipayType>100)  alipayType=100;
 
		if(OnlinePayEnum.wx.getIntVlue()==paytype)
		{
			alipayType=0;
					
			int webWxPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("webWxPay").trim());
			int androidWxPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("androidWxPay").trim());
			int iosWxPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("iosWxPay").trim());

			if(apptype==0 && webWxPay==0) //是网页客户端  且设置不支持
			{
				throw new LzPluginException("微信支付，因故暂不支持(后续会支持)，请选择其它支付方式");
			}
			if(apptype==1 && androidWxPay==0)//是android客户端  且设置不支持
			{
				throw new LzPluginException("微信支付，因故暂不支持(后续会支持)，请选择其它支付方式");
			}
			if(apptype==2 && iosWxPay==0)//是ios客户端  且设置不支持
			{
				throw new LzPluginException("微信支付，因故暂不支持(后续会支持)，请选择其它支付方式");
			}
		}
		else if(OnlinePayEnum.appliy.getIntVlue()==paytype)
		{
			int webAliPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("webAliPay").trim());
			int androidAliPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("androidAliPay").trim());
			int iosAliPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("iosAliPay").trim());
			
			if(apptype==0 && webAliPay==0) //是网页客户端  且设置不支持
			{
				throw new LzPluginException("支付宝支付，因故暂不支持(后续会支持)，请选择其它支付方式");
			}
			if(apptype==1 && androidAliPay==0)//是android客户端  且设置不支持
			{
				throw new LzPluginException("支付宝支付，因故暂不支持(后续会支持)，请选择其它支付支付");
			}
			if(apptype==2 && iosAliPay==0) //是ios客户端  且设置不支持
			{
				throw new LzPluginException("支付宝支付，因故暂不支持(后续会支持)，请选择其它支付支付");
			}
			
			if(apptype==1)  //ios
			{
				if(alipayType>=100)
				{
					alipayType=1;//使用聚合支付宝
				}
				else if(alipayType<=0)
				{
					alipayType=0;//使用原生支付宝
				}
				else
				{
					int ran=CacheClass.getRandomNum(1, 100);
					if(ran<=alipayType) //使用聚合支付宝
					{
						alipayType=1;
					}
					else              //使用原生支付宝
					{
						alipayType=0;
					}
				}
				
			}
			else if(apptype==2) //android
			{
				if(alipayforandroid>0)
				{
					if(alipayType>=100)
					{
						alipayType=1;//使用聚合支付宝
					}
					else if(alipayType<=0)
					{
						alipayType=0;//使用原生支付宝
					}
					else
					{
						int ran=CacheClass.getRandomNum(1, 100);
						if(ran<=alipayType) //使用聚合支付宝
						{
							alipayType=1;
						}
						else              //使用原生支付宝
						{
							alipayType=0;
						}
					}
				}
				else
				{
					alipayType=0;   //使用原生支付宝
				}

			}
			else  //网页
				alipayType=0;
			
		} 
		else if(OnlinePayEnum.bank.getIntVlue()==paytype)
		{
			alipayType=0;
			
			int webUnionPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("webUnionPay").trim());
			int androidUnionPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("androidUnionPay").trim());
			int iosUnionPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("iosUnionPay").trim());
			if(apptype==0 && webUnionPay==0) //是网页客户端  且设置不支持
			{
				throw new LzPluginException("银联支付，因故暂不支持(后续会支持)，请选择其它支付");
			}
			if(apptype==1 && androidUnionPay==0)//是android客户端  且设置不支持
			{
				throw new LzPluginException("银联支付，因故暂不支持(后续会支持)，请选择其它支付");
			}
			if(apptype==2 && iosUnionPay==0) //是ios客户端  且设置不支持
			{
				throw new LzPluginException("银联支付，因故暂不支持(后续会支持)，请选择其它支付");
			}
		}
		else if(OnlinePayEnum.icard.getIntVlue()==paytype)
		{
			alipayType=0;
			
			int BalancePay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("balancePay").trim());
			if(BalancePay==0)
			{
				throw new LzPluginException("余额支付，暂不支持，请选择其它支付方式");
			}
		}
		else if(OnlinePayEnum.iappay.getIntVlue()==paytype)
		{
			alipayType=0;
			
			int IapPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("iapPay").trim());
			IapPay=0;
			if(IapPay==0)
			{
				throw new LzPluginException("爱贝云支付，暂不支持，请选择其它支付方式");
			}
		}
		else
		{
			throw new LzPluginException("支付类型错误 ");
		}

		if(DataObj.projectid.endsWith(","))
		{
			DataObj.projectid=DataObj.projectid.substring(0,DataObj.projectid.length()-1);
		}
		if(DataObj.selectextra.endsWith("#&"))
		{
			DataObj.selectextra=DataObj.selectextra.substring(0,DataObj.selectextra.length()-2);
		}
		if(DataObj.num.endsWith(","))
		{
			DataObj.num=DataObj.num.substring(0,DataObj.num.length()-1);
		}
		
		String[] strIdArr=DataObj.projectid.split(",");
		DataObj.selectextra=DataObj.selectextra.replaceAll("	", "");

		DataObj.selectextra=DataObj.selectextra.replace(r, s);
		DataObj.selectextra=DataObj.selectextra.replace(n, s);
		String[] selectextraArr=DataObj.selectextra.split("#&");
		String[] strNumArr=DataObj.num.split(",");
		
		if(strIdArr.length!=selectextraArr.length || strIdArr.length!=strNumArr.length)
		{
			throw new LzPluginException("参数不正确 ");
		}
		
		//取用户数据
		CrowdUserAuthClass user=CrowdUserAuthCache.getInstance().getUser(userid);
		if(user==null )
		{
			throw new LzPluginException("用户不存在！");
		}
		float totalrmb=0,totalrmbvip=0;
		 //下单前检验
		for(int i=0;i<strIdArr.length;i++)
		{
			if(CacheClass.isEmpty(strIdArr[i]) || CacheClass.getIntValue(strNumArr[i])<=0)
			{
				throw new LzPluginException("参数不正确！");
			}
			CrowdSysProjectClass project= CrowdSysProjectCache.getInstance().load_Goods_Info_ById(CacheClass.getIntValue(strIdArr[i]));
			if(project==null)
			{
				throw new LzPluginException("项目不存在！");
			}	
			if(!CacheClass.isEmpty(project.extra) && CacheClass.isEmpty(selectextraArr[i]))
			{
				throw new LzPluginException("请选择规格！");
			}
			if(CacheClass.getIntValue(project.limitenum)<CacheClass.getIntValue(project.supportnum)+CacheClass.getIntValue(strNumArr[i]))
			{
				throw new LzPluginException("商品库存没啦！ "+project.limitenum +" "+project.supportnum);
			}
			float tmprmb=CacheClass.getIntValue(strNumArr[i])*CacheClass.getFloatValue(project.packageprice)+CacheClass.getFloatValue(project.frieght);
			if(CacheClass.getIntValue(project.viplevel)!=0) //是送vip商品
			{
				totalrmbvip=totalrmbvip+tmprmb;
			}
			//计算总价
			totalrmb=totalrmb+tmprmb;
			
		}
		
		if(totalrmb>=50000)
		{
			throw new LzPluginException("总额需少于5万");
		}
		
		//vip订单金额是否超额
		if(totalrmbvip>0)
		{
			float maxbuyviprmb=CacheClass.getFloatValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("maxbuyviprmb").trim());
			int maxbuyvipdays=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("maxbuyvipdays").trim());
			float vipOrderTotalRmb=CrowdOrderCache.getInstance().Get_OrderVipRmbByUseridDays(userid, maxbuyvipdays);
			if(vipOrderTotalRmb+totalrmbvip>maxbuyviprmb)
			{
				throw new LzPluginException("近"+maxbuyvipdays+"天内购送VIP商品总额不得超过"+maxbuyviprmb+"元。");
			}
		}
		
		
		if(OnlinePayEnum.icard.getIntVlue() == paytype && totalrmb>CacheClass.getFloatValue(user.nowrmb))
		{
			throw new LzPluginException("您的余额不足");
		}
		
		//下单
		OrderPayParm tmp= CacheClass.getSYS_OrderCacheManager().Add_Order(userid,strIdArr, strNumArr, selectextraArr, paytype,DataObj.address,DataObj.shengid,DataObj.cityid,alipayType);
		if (tmp == null) {
			throw new LzPluginException("数据库操作出错");
		}

		// 生成result包给用户		
		PublicData data = new PublicData();	
		//生成支付接口所需参数
		String url = "";
		if (OnlinePayEnum.appliy.getIntVlue() == paytype) {
			
			if(alipayType==0)
			{
				alipay_ask_DataClass alipay = new alipay_ask_DataClass();
				alipay.out_trade_no =tmp.payid;//tmp.order_sn;//订单号
				alipay.total_fee =tmp.totalrmb;//tmp.total;  //总金额
				alipay.subject = tmp.projectname;//goods.name;//物品名
				alipay.body = tmp.projectname.trim();//goods.name;  //物品详情
				
				url = alipay_ask_Provider.ask(alipay);
				data.params = url;
				data.AlipayType=alipayType+"";
				data.info = "增加订单成功";
			}
			else //
			{
				SortedMap<String, String> map = new TreeMap<String, String>();
				map.put("version", CorefireConfig.version);
			    map.put("mch_id", CorefireConfig.getMch_id());
		        map.put("appid", CorefireConfig.getAppid());
		        map.put("method", "mbupay.alipay.wap");
		        map.put("notify_url", CorefireConfig.getNotify_url());
		        
		        map.put("body", tmp.projectname.trim());
		        map.put("out_trade_no", tmp.payid);
		        map.put("total_fee", (int)(CacheClass.getFloatValue(tmp.totalrmb) * 100 )+ "");
		        map.put("scene", "bar_code");
		        map.put("nonce_str", tmp.payid);//随机数
		        //map.put("limit_pay", "no_credit");//此字段屏蔽信用卡  添加屏蔽,不添加 不屏蔽。
		        

		        Map<String,String> params = SignUtils.paraFilter(map);
		        StringBuilder buf = new StringBuilder((params.size() +1) * 10);
		        SignUtils.buildPayParams(buf,params,false);
		        String preStr = buf.toString();
		        String sign = MD5.sign(preStr, "&key=" + CorefireConfig.getKey(), "utf-8").toUpperCase();
		            
		        map.put("sign", sign);
		        
		        System.out.println("下单发送="+JSON.toJSONString(map));
		        
		        String reqUrl = CorefireConfig.getCommon_url();
		        String res = CorefireHttpPost.connect(reqUrl, map);
		        Map<String,String> resultMap = XmlUtils.xml2map(res, "xml");
		        System.out.println("下单接收="+JSON.toJSONString(resultMap));
	            if("FAIL".equals(resultMap.get("return_code"))){
	            	throw new LzPluginException("获取预售id失败");
	    		}else if("SUCCESS".equals(resultMap.get("return_code"))){
		            if(resultMap.containsKey("sign")){
		            	if(!SignUtils.checkParam(resultMap, CorefireConfig.getKey())){
		            		throw new LzPluginException("获取预售id--验证签名不通过"); 
		            	}else{
		            		if("FAIL".equals(resultMap.get("result_code"))){
		            			throw new LzPluginException("获取预售id--错误代码:"+ resultMap.get("err_code"));
		               		}
		            		else
		            		{
		            			String prepay_id=resultMap.get("prepay_id");
		        				data.params = prepay_id;
		        				data.AlipayType=alipayType+"";
		        				data.info = "增加订单成功";
		            		}
		            	}
		            } else{
		            	throw new LzPluginException("获取预售id--没有签名信息");
		            }
	    		}
			}

		} else if (OnlinePayEnum.wx.getIntVlue() == paytype) {
			Tenpay_ask_DataClass wx = new Tenpay_ask_DataClass();
			Tenpay_ask_Provider wx_provider = new Tenpay_ask_Provider();
			wx.out_trade_no = tmp.payid;//tmp.order_sn;//订单号;
			wx.total_fee =(int)(CacheClass.getFloatValue(tmp.totalrmb) * 100 )+ "";//总金额
			wx.body = tmp.projectname.trim();//goods.name;//物品名  goods.name;
			wx.userid = DataObj.userid;
			url = wx_provider.ask(wx);
			data.params = url;
			data.info = "增加订单成功";
		} else if (OnlinePayEnum.bank.getIntVlue() == paytype) {
			/*  apptype 0:网页   1:android  2:ios */
			if(apptype==1 || apptype==2)
			{
				Map<String, String> requestData = new HashMap<String, String>();
				
				/***银联全渠道系统，产品参数，除了encoding自行选择外其他不需修改***/
				requestData.put("version", DemoBase.version);   			  //版本号，全渠道默认值
				requestData.put("encoding", DemoBase.encoding_UTF8); 			  //字符集编码，可以使用UTF-8,GBK两种方式
				requestData.put("signMethod", "01");            			  //签名方法，只支持 01：RSA方式证书加密
				requestData.put("txnType", "01");               			  //交易类型 ，01：消费
				requestData.put("txnSubType", "01");            			  //交易子类型， 01：自助消费
				requestData.put("bizType", "000201");           			  //业务类型，B2C网关支付，手机wap支付
				requestData.put("channelType", "08");           			  //渠道类型，这个字段区分B2C网关支付和手机wap支付；07：PC,平板  08：手机
				
				/***商户接入参数***/
				requestData.put("merId", DemoBase.merId);    	          		//商户号码，请改成自己申请的正式商户号或者open上注册得来的777测试商户号
				requestData.put("accessType", "0");             			  //接入类型，0：直连商户 
				requestData.put("orderId",tmp.order_sn.replace("-", ""));             //商户订单号，8-40位数字字母，不能含“-”或“_”，可以自行定制规则		
				requestData.put("txnTime", DemoBase.getCurrentTime());        //订单发送时间，取系统时间，格式为YYYYMMDDhhmmss，必须取当前时间，否则会报txnTime无效
				requestData.put("accType", "01");					 	      //账号类型 01：银行卡02：存折03：IC卡帐号类型(卡介质)
				requestData.put("currencyCode", "156");         			  //交易币种（境内商户一般是156 人民币）		
				requestData.put("txnAmt", (int)(CacheClass.getFloatValue(tmp.totalrmb) * 100 )+ "");             			      //交易金额，单位分，不要带小数点
				requestData.put("reqReserved", tmp.payid);        		      //请求方保留域，如需使用请启用即可；透传字段（可以实现商户自定义参数的追踪）本交易的后台通知,对本交易的交易状态查询交易、对账文件中均会原样返回，商户可以按需上传，长度为1-1024个字节		
				
				//后台通知地址（需设置为【外网】能访问 http https均可），支付成功后银联会自动将异步通知报文post到商户上送的该地址，失败的交易银联不会发送后台通知
				//后台通知参数详见open.unionpay.com帮助中心 下载  产品接口规范  网关支付产品接口规范 消费交易 商户通知
				//注意:1.需设置为外网能访问，否则收不到通知    2.http https均可  3.收单后台通知后需要10秒内返回http200或302状态码 
				//    4.如果银联通知服务器发送通知后10秒内未收到返回状态码或者应答码非http200，那么银联会间隔一段时间再次发送。总共发送5次，每次的间隔时间为0,1,2,4分钟。
				//    5.后台通知地址如果上送了带有？的参数，例如：http://abc/web?a=b&c=d 在后台通知处理程序验证签名之前需要编写逻辑将这些字段去掉再验签，否则将会验签失败
				requestData.put("backUrl", "http://newpay.91limao.com/"+DemoBase.backUrl);
				
				/**请求参数设置完毕，以下对请求参数进行签名并生成html表单，将表单写入浏览器跳转打开银联页面**/
				Map<String, String> reqData  = AcpService.sign(requestData,DemoBase.encoding_UTF8);  //报文中certId,signature的值是在signData方法中获取并自动赋值的，只要证书配置正确即可。
				
				String requestAppUrl = SDKConfig.getConfig().getAppRequestUrl();  //获取请求银联的前台地址：对应属性文件acp_sdk.properties文件中的acpsdk.frontTransUrl
				Map<String, String> rspData = AcpService.post(reqData,requestAppUrl,DemoBase.encoding_UTF8);  //发送请求报文并接受同步应答（默认连接超时时间30秒，读取返回结果超时时间30秒）;
				
				/**对应答码的处理，请根据您的业务逻辑来编写程序,以下应答码处理逻辑仅供参考------------->**/
				//应答码规范参考open.unionpay.com帮助中心 下载  产品接口规范  《平台接入接口规范-第5部分-附录》
				
				if(!rspData.isEmpty()){
					if(AcpService.validate(rspData, DemoBase.encoding_UTF8)){
						LogUtil.writeLog("验证签名成功");
						String respCode = rspData.get("respCode") ;
						if(("00").equals(respCode)){
							//成功,获取tn号
							url = rspData.get("tn");
							data.params = url;
							data.info = "增加订单成功";
						}else{
							//其他应答码为失败请排查原因或做失败处理
							throw new LzPluginException("失败,respCode="+respCode);
						}
					}else{
						LogUtil.writeErrorLog("验证签名失败");
						throw new LzPluginException("验证签名失败");
						//TODO 检查验证签名失败的原因
					}
				}else{
					//未返回正确的http状态
					throw new LzPluginException("未获取到返回报文或返回http状态码非200 ");
				}
				String reqMessage = DemoBase.genHtmlResult(reqData);
				String rspMessage = DemoBase.genHtmlResult(rspData);
				System.out.println("请求报文:"+reqMessage);
				System.out.println("应答报文:"+rspMessage);
			}
			else  //网页　银联支付
			{
				
				data.info = "订单生成成功";
				data.orderid=tmp.payid;
				data.paytype=paytype+"";
			}

		}  
		else if(OnlinePayEnum.iappay.getIntVlue()==paytype)  //爱贝
		{
			if(apptype==1) //android
			{
				String transid=OrderForAndroid.CheckSign(tmp.projectname.trim(),tmp.payid,CacheClass.getFloatValue(tmp.totalrmb),tmp.userid);
				if(CacheClass.isEmpty(transid))
				{
					throw new LzPluginException("验证签名失败");
				}
				data.params = transid;
				data.info = "增加订单成功";
			}
			else if(apptype==2) //ios
			{
				String transid=OrderForIos.CheckSign(tmp.projectname.trim(),tmp.payid,CacheClass.getFloatValue(tmp.totalrmb),tmp.userid);
				if(CacheClass.isEmpty(transid))
				{
					throw new LzPluginException("验证签名失败");
				}
				data.params = transid;
				data.info = "增加订单成功";
			}
			else//网页
			{
				String transid=OrderForWeb.CheckSign(tmp.projectname.trim(),tmp.payid,CacheClass.getFloatValue(tmp.totalrmb),tmp.userid);
				if(CacheClass.isEmpty(transid))
				{
					throw new LzPluginException("验证签名失败");
				}
				url=OrderForWeb.H5orPCpay_String(transid);
				//data.params = transid;
				data.params = url;
				data.info = "增加订单成功";
			}

		}
		else if (OnlinePayEnum.icard.getIntVlue() == paytype) //余额支付
		{
			String orderidlist=CrowdOrderProvider.getInstance().load_OrderidListByPayid(CacheClass.getIntValue(tmp.payid),false);
			if(CacheClass.isEmpty(orderidlist))
			{
				throw new LzPluginException("orderidlist is null ");
			}
			String[] orderidListArr=orderidlist.split(",");
			for(String orderid:orderidListArr)
			{
				CrowdOrderCache.getInstance().Deal_Order(orderid); //余额支付成功后更新相关参数 分成等
			}
			
			data.info = "购买成功";
			
		} else {
			throw new LzPluginException("支付类型错误 ");
		}
		

		data.state = "1";
		data.m = m+"";
		data.paytype=paytype+"";

		return data;
		
		
	}
	
	
	//&新鲜宝  用户订单取消
	public static Object resultDelete_Order_ByUser(HttpServletResponse response,AsyncContext asyncContext,int m,RecvData DataObj) throws LzPluginException
	{

		// 参数检查1

		// 参数检查2
		if (CacheClass.isEmpty(DataObj.orderid)) {
			throw new LzPluginException("内容为空或者参数不正确");
		}
		// 参数检查（值范围、正确性检查）
		int orderid = CacheClass.getIntValue(DataObj.orderid);
		int userid = CacheClass.getIntValue(DataObj.userid);
		//数据库操作
		CrowdOrderDataClass orderData = CacheClass.getSYS_OrderCacheManager().loadOrderByID(orderid);
		if (OrderStateEnum.cancel.getIntVlue() == CacheClass.getIntValue(orderData.state)) {
			throw new LzPluginException("订单已取消, 不有重复操作");
		}
		if (OrderStateEnum.to_pay.getIntVlue() != CacheClass.getIntValue(orderData.state)) {
			throw new LzPluginException("众筹订单已付款, 不能取消!");
		}
		CrowdOrderDataClass tmp = CacheClass.getSYS_OrderCacheManager().cancelOrder(orderid,userid);
		// 生成result包给用户
		if (tmp==null) {
			throw new LzPluginException("取消订单失败");
		}

		return OutPrintClass.resultObj(m, "用户取消订单成功");

	}	


	
	//新鲜宝 用户对未付款(或付款失败)订单，再次付款
	public static Object resultRepay_Order_ByUser(HttpServletRequest request,HttpServletResponse response,AsyncContext asyncContext,int m,RecvData DataObj) throws Exception
	{
		
		// 参数检查
		if (CacheClass.isEmpty(DataObj.orderid))
		{
			throw new LzPluginException("内容为空或者参数不正确");
		}
		
		if (CacheClass.isEmpty(DataObj.paytype))
		{
			DataObj.paytype="0";
		}
		if (CacheClass.isEmpty(DataObj.apptype))
		{
			DataObj.apptype="0";
		}
		
		
		int userid = CacheClass.getIntValue(DataObj.userid);
		if (userid == 0) {
			throw new LzPluginException("没有登录不能操作");
		}

		int paytype = CacheClass.getIntValue(DataObj.paytype);
		/*  apptype 0:网页   1:android  2:ios */
		int apptype = CacheClass.getIntValue(DataObj.apptype);
		
		
		int alipayType=CacheClass.getIntValue(BaseDataCacheManager.getInstance().Load_Param("alipayType").trim());
		int alipayforandroid=CacheClass.getIntValue(BaseDataCacheManager.getInstance().Load_Param("alipayforandroid").trim());
		if(alipayType>100)  alipayType=100;
 
		if(OnlinePayEnum.wx.getIntVlue()==paytype)
		{
			alipayType=0;
			
			int webWxPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("webWxPay").trim());
			int androidWxPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("androidWxPay").trim());
			int iosWxPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("iosWxPay").trim());

			if(apptype==0 && webWxPay==0) //是网页客户端  且设置不支持
			{
				throw new LzPluginException("微信支付，因故暂不支持(后续会支持)，请选择其它支付方式");
			}
			if(apptype==1 && androidWxPay==0)//是android客户端  且设置不支持
			{
				throw new LzPluginException("微信支付，因故暂不支持(后续会支持)，请选择其它支付方式");
			}
			if(apptype==2 && iosWxPay==0)//是ios客户端  且设置不支持
			{
				throw new LzPluginException("微信支付，因故暂不支持(后续会支持)，请选择其它支付方式");
			}
		}
		else if(OnlinePayEnum.appliy.getIntVlue()==paytype)
		{
			int webAliPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("webAliPay").trim());
			int androidAliPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("androidAliPay").trim());
			int iosAliPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("iosAliPay").trim());
			
			if(apptype==0 && webAliPay==0) //是网页客户端  且设置不支持
			{
				throw new LzPluginException("支付宝支付，因故暂不支持(后续会支持)，请选择其它支付方式");
			}
			if(apptype==1 && androidAliPay==0)//是android客户端  且设置不支持
			{
				throw new LzPluginException("支付宝支付，因故暂不支持(后续会支持)，请选择其它支付支付");
			}
			if(apptype==2 && iosAliPay==0) //是ios客户端  且设置不支持
			{
				throw new LzPluginException("支付宝支付，因故暂不支持(后续会支持)，请选择其它支付支付");
			}
			
			if(apptype==0 && webAliPay==0) //是网页客户端  且设置不支持
			{
				throw new LzPluginException("支付宝支付，因故暂不支持(后续会支持)，请选择其它支付方式");
			}
			if(apptype==1 && androidAliPay==0)//是android客户端  且设置不支持
			{
				throw new LzPluginException("支付宝支付，因故暂不支持(后续会支持)，请选择其它支付支付");
			}
			if(apptype==2 && iosAliPay==0) //是ios客户端  且设置不支持
			{
				throw new LzPluginException("支付宝支付，因故暂不支持(后续会支持)，请选择其它支付支付");
			}
			
			if(apptype==1)  //ios
			{
				int ran=CacheClass.getRandomNum(1, 100);
				if(ran<=alipayType) //使用聚合支付宝
				{
					alipayType=1;
				}
				else              //使用原生支付宝
				{
					alipayType=0;
				}
			}
			else if(apptype==2) //android
			{
				if(alipayforandroid>0)
				{
					int ran=CacheClass.getRandomNum(1, 100);
					if(ran<=alipayType) //使用聚合支付宝
					{
						alipayType=1;
					}
					else              //使用原生支付宝
					{
						alipayType=0;
					}
				}
				else
				{
					alipayType=0;   //使用原生支付宝
				}

			}
			else  //网页
				alipayType=0;
		} 
		else	if(OnlinePayEnum.bank.getIntVlue()==paytype)
		{
			alipayType=0;
			
			int webUnionPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("webUnionPay").trim());
			int androidUnionPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("androidUnionPay").trim());
			int iosUnionPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("iosUnionPay").trim());
			if(apptype==0 && webUnionPay==0) //是网页客户端  且设置不支持
			{
				throw new LzPluginException("银联支付，因故暂不支持(后续会支持)，请选择其它支付");
			}
			if(apptype==1 && androidUnionPay==0)//是android客户端  且设置不支持
			{
				throw new LzPluginException("银联支付，因故暂不支持(后续会支持)，请选择其它支付");
			}
			if(apptype==2 && iosUnionPay==0) //是ios客户端  且设置不支持
			{
				throw new LzPluginException("银联支付，因故暂不支持(后续会支持)，请选择其它支付");
			}
		}
		else if(OnlinePayEnum.iappay.getIntVlue()==paytype)
		{
			alipayType=0;
			
			int IapPay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("iapPay").trim());
			IapPay=0;
			if(IapPay==0)
			{
				throw new LzPluginException("爱贝云支付，暂不支持，请选择其它支付方式");
			}
		}
		else if(OnlinePayEnum.icard.getIntVlue()==paytype)
		{
			alipayType=0;
			int BalancePay=CacheClass.getIntValue(CacheClass.getSYS_BaseDataCacheManager().Load_Param("balancePay").trim());
			if(BalancePay==0)
			{
				throw new LzPluginException("余额支付，暂不支持，请选择其它支付方式");
			}
		}

	
        //取订单信息
		CrowdOrderDataClass tmp = CacheClass.getSYS_OrderCacheManager().updateOrderForPayByID(CacheClass.getIntValue(DataObj.orderid),paytype,alipayType);
		if (tmp == null) {
			throw new LzPluginException("无此订单");
		}
		
		if (OrderStateEnum.to_pay.getIntVlue() != CacheClass.getIntValue(tmp.state)) {
			throw new LzPluginException("订单已取消或已支付,不能再支付");
		}
	

		// 生成result包给用户		
		PublicData data = new PublicData();	
		//生成支付接口所需参数
		String url = "";
		if (OnlinePayEnum.appliy.getIntVlue() == paytype) {
			if(alipayType==0)
			{
				alipay_ask_DataClass alipay = new alipay_ask_DataClass();
				alipay.out_trade_no =tmp.payid;//tmp.order_sn;//订单号
				alipay.total_fee =tmp.totalrmb;//tmp.total;  //总金额
				alipay.subject = tmp.projectname.trim();//goods.name;//物品名
				alipay.body = tmp.projectname.trim();//goods.name;  //物品详情
				
				url = alipay_ask_Provider.ask(alipay);
				data.params = url;
				data.AlipayType=alipayType+"";
				data.info = "增加订单成功";
			}
			else //
			{
				SortedMap<String, String> map = new TreeMap<String, String>();
				map.put("version", CorefireConfig.version);
			    map.put("mch_id", CorefireConfig.getMch_id());
		        map.put("appid", CorefireConfig.getAppid());
		        map.put("method", "mbupay.alipay.wap");
		        map.put("notify_url", CorefireConfig.getNotify_url());
		        
		        map.put("body", tmp.projectname.trim());
		        map.put("out_trade_no", tmp.payid);
		        map.put("total_fee", (int)(CacheClass.getFloatValue(tmp.totalrmb) * 100 )+ "");
		        map.put("scene", "bar_code");
		        map.put("nonce_str", CacheClass.getTime()+tmp.payid);//随机数
		        //map.put("limit_pay", "no_credit");//此字段屏蔽信用卡  添加屏蔽,不添加 不屏蔽。
		        

		        Map<String,String> params = SignUtils.paraFilter(map);
		        StringBuilder buf = new StringBuilder((params.size() +1) * 10);
		        SignUtils.buildPayParams(buf,params,false);
		        String preStr = buf.toString();
		        String sign = MD5.sign(preStr, "&key=" + CorefireConfig.getKey(), "utf-8").toUpperCase();
		            
		        map.put("sign", sign);
		        String reqUrl = CorefireConfig.getCommon_url();
		        String res = CorefireHttpPost.connect(reqUrl, map);
		        Map<String,String> resultMap = XmlUtils.xml2map(res, "xml");
	            if("FAIL".equals(resultMap.get("return_code"))){
	            	throw new LzPluginException("获取预售id失败");
	    		}else if("SUCCESS".equals(resultMap.get("return_code"))){
		            if(resultMap.containsKey("sign")){
		            	if(!SignUtils.checkParam(resultMap, CorefireConfig.getKey())){
		            		throw new LzPluginException("获取预售id--验证签名不通过"); 
		            	}else{
		            		if("FAIL".equals(resultMap.get("result_code"))){
		            			throw new LzPluginException("获取预售id--错误代码:"+ resultMap.get("err_code"));
		               		}
		            		else
		            		{
		            			String prepay_id=resultMap.get("prepay_id");
		        				data.params = prepay_id;
		        				data.AlipayType=alipayType+"";
		        				data.info = "增加订单成功";
		            		}
		            	}
		            } else{
		            	throw new LzPluginException("获取预售id--没有签名信息");
		            }
	    		}
			}

		} else if (OnlinePayEnum.wx.getIntVlue() == paytype) {
			Tenpay_ask_DataClass wx = new Tenpay_ask_DataClass();
			Tenpay_ask_Provider wx_provider = new Tenpay_ask_Provider();
			wx.out_trade_no = tmp.payid;//tmp.order_sn;//订单号;
			wx.total_fee =(int)(CacheClass.getFloatValue(tmp.totalrmb) * 100 )+ "";//总金额
			wx.body = tmp.projectname.trim();//goods.name;//物品名  goods.name;
			wx.userid = DataObj.userid;
			url = wx_provider.ask(wx);
			data.params = url;
			data.info = "更新订单成功";
		} else if (OnlinePayEnum.bank.getIntVlue() == paytype) {
			/*  apptype 0:网页   1:android  2:ios */
			if(apptype==1 || apptype==2)
			{
				Map<String, String> requestData = new HashMap<String, String>();
				
				/***银联全渠道系统，产品参数，除了encoding自行选择外其他不需修改***/
				requestData.put("version", DemoBase.version);   			  //版本号，全渠道默认值
				requestData.put("encoding", DemoBase.encoding_UTF8); 			  //字符集编码，可以使用UTF-8,GBK两种方式
				requestData.put("signMethod", "01");            			  //签名方法，只支持 01：RSA方式证书加密
				requestData.put("txnType", "01");               			  //交易类型 ，01：消费
				requestData.put("txnSubType", "01");            			  //交易子类型， 01：自助消费
				requestData.put("bizType", "000201");           			  //业务类型，B2C网关支付，手机wap支付
				requestData.put("channelType", "08");           			  //渠道类型，这个字段区分B2C网关支付和手机wap支付；07：PC,平板  08：手机
				
				/***商户接入参数***/
				requestData.put("merId", DemoBase.merId);    	          		//商户号码，请改成自己申请的正式商户号或者open上注册得来的777测试商户号
				requestData.put("accessType", "0");             			  //接入类型，0：直连商户 
				requestData.put("orderId",tmp.order_sn.replace("-", ""));             //商户订单号，8-40位数字字母，不能含“-”或“_”，可以自行定制规则		
				requestData.put("txnTime", DemoBase.getCurrentTime());        //订单发送时间，取系统时间，格式为YYYYMMDDhhmmss，必须取当前时间，否则会报txnTime无效
				requestData.put("accType", "01");					 	      //账号类型 01：银行卡02：存折03：IC卡帐号类型(卡介质)
				requestData.put("currencyCode", "156");         			  //交易币种（境内商户一般是156 人民币）		
				requestData.put("txnAmt", (int)(CacheClass.getFloatValue(tmp.totalrmb) * 100 )+ "");             			      //交易金额，单位分，不要带小数点
				requestData.put("reqReserved", tmp.payid);        		      //请求方保留域，如需使用请启用即可；透传字段（可以实现商户自定义参数的追踪）本交易的后台通知,对本交易的交易状态查询交易、对账文件中均会原样返回，商户可以按需上传，长度为1-1024个字节		
				
				//后台通知地址（需设置为【外网】能访问 http https均可），支付成功后银联会自动将异步通知报文post到商户上送的该地址，失败的交易银联不会发送后台通知
				//后台通知参数详见open.unionpay.com帮助中心 下载  产品接口规范  网关支付产品接口规范 消费交易 商户通知
				//注意:1.需设置为外网能访问，否则收不到通知    2.http https均可  3.收单后台通知后需要10秒内返回http200或302状态码 
				//    4.如果银联通知服务器发送通知后10秒内未收到返回状态码或者应答码非http200，那么银联会间隔一段时间再次发送。总共发送5次，每次的间隔时间为0,1,2,4分钟。
				//    5.后台通知地址如果上送了带有？的参数，例如：http://abc/web?a=b&c=d 在后台通知处理程序验证签名之前需要编写逻辑将这些字段去掉再验签，否则将会验签失败
				requestData.put("backUrl", "http://newpay.91limao.com/"+DemoBase.backUrl);

				/**请求参数设置完毕，以下对请求参数进行签名并生成html表单，将表单写入浏览器跳转打开银联页面**/
				Map<String, String> reqData  = AcpService.sign(requestData,DemoBase.encoding_UTF8);  //报文中certId,signature的值是在signData方法中获取并自动赋值的，只要证书配置正确即可。
				
				String requestAppUrl = SDKConfig.getConfig().getAppRequestUrl();  //获取请求银联的前台地址：对应属性文件acp_sdk.properties文件中的acpsdk.frontTransUrl
				Map<String, String> rspData = AcpService.post(reqData,requestAppUrl,DemoBase.encoding_UTF8);  //发送请求报文并接受同步应答（默认连接超时时间30秒，读取返回结果超时时间30秒）;
				
				/**对应答码的处理，请根据您的业务逻辑来编写程序,以下应答码处理逻辑仅供参考------------->**/
				//应答码规范参考open.unionpay.com帮助中心 下载  产品接口规范  《平台接入接口规范-第5部分-附录》
				if(!rspData.isEmpty()){
					if(AcpService.validate(rspData, DemoBase.encoding_UTF8)){
						LogUtil.writeLog("验证签名成功");
						String respCode = rspData.get("respCode") ;
						if(("00").equals(respCode)){
							//成功,获取tn号
							url = rspData.get("tn");
							data.params = url;
							data.info = "增加订单成功";
						}else{
							//其他应答码为失败请排查原因或做失败处理
							throw new LzPluginException("失败,respCode="+respCode);
						}
					}else{
						LogUtil.writeErrorLog("验证签名失败");
						throw new LzPluginException("验证签名失败");
						//TODO 检查验证签名失败的原因
					}
				}else{
					//未返回正确的http状态
					throw new LzPluginException("未获取到返回报文或返回http状态码非200 ");
				}
				String reqMessage = DemoBase.genHtmlResult(reqData);
				String rspMessage = DemoBase.genHtmlResult(rspData);
				System.out.println("请求报文:"+reqMessage);
				System.out.println("应答报文:"+rspMessage);
			}
			else  //网页　银联支付
			{
				data.params = url;
				data.info = "订单生成成功";
				data.orderid=tmp.orderid;
			}

		}  
		else if(OnlinePayEnum.iappay.getIntVlue()==paytype)
		{
			if(apptype==1) //android
			{
				String transid=OrderForAndroid.CheckSign(tmp.projectname.trim(),tmp.orderid,CacheClass.getFloatValue(tmp.totalrmb),tmp.userid);
				if(CacheClass.isEmpty(transid))
				{
					throw new LzPluginException("验证签名失败");
				}
				data.params = transid;
				data.info = "更新订单成功";
			}
			else if(apptype==2) //ios
			{
				String transid=OrderForIos.CheckSign(tmp.projectname.trim(),tmp.orderid,CacheClass.getFloatValue(tmp.totalrmb),tmp.userid);
				if(CacheClass.isEmpty(transid))
				{
					throw new LzPluginException("验证签名失败");
				}
				data.params = transid;
				data.info = "更新订单成功";
			}
/*			
			if(apptype==1 || apptype==2)
			{
				String transid=OrderForWeb.CheckSign(tmp.projectname,tmp.orderid,CacheClass.getFloatValue(tmp.totalrmb),tmp.userid);
				if(CacheClass.isEmpty(transid))
				{
					throw new LzPluginException("验证签名失败");
				}
				url=OrderForWeb.H5orPCpay_String(transid);
				data.params = url;
				data.info = "增加订单成功";
			}
*/
			else//网页
			{
				String transid=OrderForWeb.CheckSign(tmp.projectname.trim(),tmp.orderid,CacheClass.getFloatValue(tmp.totalrmb),tmp.userid);
				if(CacheClass.isEmpty(transid))
				{
					throw new LzPluginException("验证签名失败");
				}
				//OrderForWeb.H5orPCpay(transid);
				url=OrderForWeb.H5orPCpay_String(transid);
				//data.params = transid;
				data.params = url;
				data.info = "更新订单成功";
			}

		}
		else if (OnlinePayEnum.icard.getIntVlue() == paytype) //余额支付
		{
			//余额支付成功后更新相关参数 分成等
			if(CrowdOrderCache.getInstance().resultRepay_Order_ByUser(tmp)!=null) 
				CrowdOrderCache.getInstance().Deal_Order(tmp.orderid);
			data.info = "购买成功";
			
		} else {
			throw new LzPluginException("支付类型错误 ");
		}
		

		data.state = "1";
		data.m = m+"";
		data.paytype=paytype+"";



		return data;
		
		
	}
	
	
	
	
	//新鲜宝   取用户订单列表（所有）
	public static Object load_OrderByUser_id(HttpServletResponse response,AsyncContext asyncContext,int m,RecvData DataObj) throws LzPluginException
	{

		if (CacheClass.isEmpty(DataObj.curpage))
			DataObj.curpage = "1";
		if (CacheClass.isEmpty(DataObj.type))
			DataObj.type = "-1";
		

		// 参数检查（值范围、正确性检查）
		int curpage = CacheClass.getIntValue(DataObj.curpage);
		int type = CacheClass.getIntValue(DataObj.type);
		int userid = CacheClass.getIntValue(DataObj.userid);
		
		PublicData data=CrowdOrderCache.getInstance().load_OrderByUser_id(userid,type,curpage);

		data.state = "1";
		data.m = m+"";
		data.info = "获取订单列表成功";

		return data;
		
	}	
	
	//新鲜宝 查询订单详细情况 by id
	public static Object resultSYSload_OrderById(HttpServletResponse response,AsyncContext asyncContext,int m,RecvData DataObj) throws LzPluginException
	{
		// 参数检查
		if (CacheClass.isEmpty(DataObj.orderid)) {
			throw new LzPluginException("内容为空或者参数不正确");
		}
		// 参数检查（值范围、正确性检查）
		int orderid = CacheClass.getIntValue(DataObj.orderid);

		CrowdOrderDataClass tmp = CrowdOrderCache.getInstance().loadOrderByID(orderid);
		if (tmp == null) {
			throw new LzPluginException("数据库操作出错");
		}

		PublicData data = new PublicData();
		data.obj = tmp;
		data.state = "1";
		data.m = m+"";
		data.info = "获取订单详情成功";
		
		return data;
		
	}
	
	//&新鲜宝 确认收货
	public static Object resultSYSOrderScore(HttpServletResponse response,AsyncContext asyncContext,int m,RecvData DataObj) throws LzPluginException
	{

		// 参数检查2(非空检查)
		if (CacheClass.isEmpty(DataObj.orderid)) 
		{
			throw new LzPluginException("内容为空或者参数不正确");
		}
		
		// 参数检查（值范围、正确性检查）
		int userid = CacheClass.getIntValue(DataObj.userid);
		int orderid = CacheClass.getIntValue(DataObj.orderid);
		
		//订单签收
		CrowdOrderDataClass order=CrowdOrderCache.getInstance().Update_sign(orderid, userid);
		if (order==null) {
			throw new LzPluginException("订单签收－操作失败");
		}
	
		return OutPrintClass.resultObj(m, "订单签收－操作成功");

	}
	
	
	//新鲜宝 门店用户扫码——取某订单详情
	public static Object resultSYSload_OrderForShopuser(HttpServletResponse response,AsyncContext asyncContext,int m,RecvData DataObj) throws LzPluginException
	{
		// 参数检查
		if (CacheClass.isEmpty(DataObj.id) || CacheClass.isEmpty(DataObj.ordersn) ) {
			throw new LzPluginException("内容为空或者参数不正确");
		}
		// 参数检查（值范围、正确性检查）
		int userid = CacheClass.getIntValue(DataObj.userid);
		//当前用户是否为门店用户
		CrowdUserAuthClass authTmp=CrowdUserAuthCache.getInstance().getUser(userid);
		if(authTmp==null || CacheClass.getIntValue(authTmp.isshopuser)==0)
		{
			throw new LzPluginException("非门店用户，您无此权限，请联系客服!");
		}
		int id = CacheClass.getIntValue(DataObj.id);

		CrowdOrderDataClass tmp = CacheClass.getSYS_OrderCacheManager().loadOrderByID(id);
		if (tmp == null) {
			throw new LzPluginException("数据库操作出错");
		}

		if (!DataObj.ordersn.equalsIgnoreCase(tmp.order_sn)) {
			throw new LzPluginException("订单不存在");
		}

		PublicData data = new PublicData();
		data.obj = tmp;
		data.state = "1";
		data.m = m+"";
		data.info = "获取订单详情成功";
		
		return data;
		
	}	
	
	
	
	//新鲜宝  支付回调　（支付宝，微信，银联）
	public static Object OnlinePay_return(HttpServletResponse response,AsyncContext asyncContext,int m,RecvData DataObj) throws Exception
	{
		
		if (CacheClass.isEmpty(DataObj.type)) {
			throw new LzPluginException("支付类型不能为空");
		}
		if (CacheClass.isEmpty(DataObj.params)) {
			throw new LzPluginException("参数值不能为空 ");
		}
		HashMap<String, String> params = new HashMap<String, String>();
		JSONObject pj = (JSONObject) JSON.parse(DataObj.params);

		for (Entry<String, Object> e : pj.entrySet()) {
			params.put(e.getKey(), (String) e.getValue());
		}

		int type = CacheClass.getIntValue(DataObj.type);

		int paytype=0;
		
		String order_sn = (String) pj.get("out_trade_no");
		boolean iserror = false;
		String errormsg = "";
		if (OnlinePayEnum.appliy.getIntVlue() == type) {
			paytype=OnlinePayEnum.appliy.getIntVlue();
			if (!verify_alipay(params)) {
				iserror = true;
				errormsg = DataObj.params;
			}

		} else if (OnlinePayEnum.wx.getIntVlue() == type) {
			paytype=OnlinePayEnum.wx.getIntVlue();
			if (!verify_wx(params)) {
				iserror = true;
				errormsg = DataObj.params;
			}
		} else {
			throw new LzPluginException("充值类型错误 ");
		}
		
		

		if(!CrowdOrderCache.getInstance().Deal_Order(order_sn,paytype,iserror, errormsg))
		{
			PublicData data = new PublicData();
			data.userid = DataObj.userid;
			data.value = "true";
			data.state = "1";
			data.m = m+"";
			data.info = "冲值成功";
			
			return data;

		}
		else
		{
			PublicData data = new PublicData();
			data.userid = DataObj.userid;
			data.value = "false";
			data.state = "0";
			data.m = m+"";
			data.info = "冲值失败";
			
			return data;
		}
		
	}

	//新鲜宝   支付回调　（支付宝，微信，银联,爱贝）
	public static boolean OnlinePay_return(String typeStr ,Map<String,String> params )
	{

		int type = CacheClass.getIntValue(typeStr);
		boolean iserror = false;
		String payid = "";
		String errormsg = "";
		int paytype=0;
		if(OnlinePayEnum.iappay.getIntVlue()==type)//爱贝
		{
			paytype=OnlinePayEnum.iappay.getIntVlue();
			String signtype = (String) params.get("signtype");
			if(signtype==null)
			{
				//System.out.println(""+respData);
				iserror = true;
				//errormsg = JSON.toJSONString(params);
			}else{
				/*
				 * 调用验签接口
				 * 主要 目的 确定 收到的数据是我们 发的数据，是没有被非法改动的
				*/
				String transdata = (String) params.get("transdata");
				String sign = (String) params.get("sign");
				String PLATP_KEY = (String) params.get("PLATP_KEY");
			
				if (SignHelper.verify(transdata, sign, PLATP_KEY)) {//验证成功
					System.out.println("verify ok");
					IappayData data=JSON.parseObject(transdata, IappayData.class);
					if(CacheClass.getIntValue(data.result)==0) //交易成功
					{
						payid=data.cporderid;
						iserror = false;
					}
					else //
					{
						payid=data.cporderid;
						iserror = true;
						errormsg = "交易失败";
					}
					
						
				} else { //验证失败
					iserror = true;
					errormsg = "验证失败";
				}
			}
		}
		else
		{
			System.out.println(JSON.toJSONString(params));
			payid = (String) params.get("out_trade_no");
			System.out.println("type="+type);
			if (OnlinePayEnum.appliy.getIntVlue() == type) { //支付宝
				paytype=OnlinePayEnum.appliy.getIntVlue();
				if (!verify_alipay(params)) {
					iserror = true;
					errormsg = JSON.toJSONString(params);
				}
	
			} else if (OnlinePayEnum.wx.getIntVlue() == type) {//微信
				paytype=OnlinePayEnum.wx.getIntVlue();
				try {
					if (!verify_wx(params)) {
						iserror = true;
						errormsg = JSON.toJSONString(params);
					}
				} catch (Exception e1) {
					e1.printStackTrace();
					return false;
				}
			} 
			else if(type==10)  //聚合支付宝
			{
				paytype=OnlinePayEnum.appliy.getIntVlue();
				
				System.out.println("聚合支付宝");
				if(!params.isEmpty())
				{
		            if("FAIL".equals(params.get("return_code"))){
		            	return false;
		    		}else if("SUCCESS".equals(params.get("return_code")))
		    		{
			            if(params.containsKey("sign"))
			            {
			            	if(!SignUtils.checkParam(params, CorefireConfig.getKey())){
			            		return false; 
			            	}else{
			            		if("SUCCESS".equals(params.get("result_code"))){
			            			payid = (String) params.get("out_trade_no");
									iserror = false;
			               		}
			            		else
			            		{
									iserror = true;
									errormsg = JSON.toJSONString(params);
			            		}
			            	}
			            } else{
			            	return false;
			            }
					}else{
						//未返回正确的http状态
						return false;
					}
				}
				else {
					return false;
				}
			}
			else
			{
				return false;
			}
			
		}
		
		
		boolean userid = true;
		try {
			
			
			String orderidlist=CrowdOrderProvider.getInstance().load_OrderidListByPayid(CacheClass.getIntValue(payid),iserror);
			if(CacheClass.isEmpty(orderidlist))
			{
				throw new LzPluginException("orderidlist is null ");
			}
			
			String[] orderidListArr=orderidlist.split(",");
			for(String orderid:orderidListArr)
			{
				userid = CrowdOrderCache.getInstance().Deal_Order(orderid,paytype,iserror, errormsg);
				if(userid)
				{
					break;
				}
			}
			
			
			
		} catch (Exception e1) {
			e1.printStackTrace();
			return false;
		}
		if(!userid)
		{
			//"冲值成功"
			iserror=true;
		}
		else
		{
			//"冲值失败"
			iserror=false;
		}
		
		return iserror;
	}
	
	
	
	/**
	 * 验证消息是否是支付宝发出的合法消息
	 * 
	 * @param params
	 *            通知返回来的参数数组
	 * @return 验证结果
	 * @throws Exception
	 */
	public static boolean verify_wx(Map<String, String> params)	throws Exception {
		// 商户号
		String partner = TenpayConfig.getMCH_ID();

		// 密钥
		String key = TenpayConfig.getAPP_KEY(); // "8934e7d15453e97507ef794cf7b0519d";

		ResponseHandler resHandler = new ResponseHandler(null, null);
		resHandler.setKey(key);

		// 判断签名
		if (resHandler.isTenpaySign(params)) {
			System.out.println("微信支付通知 1…out_trade_no…"+params.get("out_trade_no"));
			String return_code=params.get("return_code");
			if("SUCCESS".equalsIgnoreCase(return_code))
			{
				String result_code=params.get("result_code");
				if("SUCCESS".equalsIgnoreCase(result_code))
				{
					return true;
				}
			}
			return false;
			
			/*// 通知id
			String notify_id = params.get("notify_id");
			
			// 创建请求对象
			RequestHandler queryReq = new RequestHandler(null, null);
			// 通信对象
			TenpayHttpClient httpClient = new TenpayHttpClient();
			// 应答对象
			ClientResponseHandler queryRes = new ClientResponseHandler();

			// 通过通知ID查询，确保通知来至财付通
			queryReq.init();
			queryReq.setKey(key);
			queryReq.setGateUrl("https://gw.tenpay.com/gateway/verifynotifyid.xml");
			queryReq.setParameter("partner", partner);
			queryReq.setParameter("notify_id", notify_id);

			// 通信对象
			httpClient.setTimeOut(5);
			// 设置请求内容
			httpClient.setReqContent(queryReq.getRequestURL());
			System.out.println("queryReq: " + queryReq.getRequestURL());
			// 后台调用
			if (httpClient.call()) {
				// 设置结果参数
				queryRes.setContent(httpClient.getResContent());
				System.out.println("queryRes:" + httpClient.getResContent());
				queryRes.setKey(key);

				// 获取返回参数
				String retcode = queryRes.getParameter("retcode");
				
				// 判断签名及结果
				if ("0".equals(retcode)) {
					// && "0".equals(trade_state) && "1".equals(trade_mode)
					System.out.println("订单查询成功");
					// 取结果参数做业务处理
					System.out.println("out_trade_no:"
							+ queryRes.getParameter("out_trade_no")
							+ " transaction_id:"
							+ queryRes.getParameter("transaction_id"));
					System.out.println("trade_state:"
							+ queryRes.getParameter("trade_state")
							+ " total_fee:"
							+ queryRes.getParameter("total_fee"));
					// 如果有使用折扣券，discount有值，total_fee+discount=原请求的total_fee
					System.out.println("discount:"
							+ queryRes.getParameter("discount") + " time_end:"
							+ queryRes.getParameter("time_end"));
					// ------------------------------
					// 处理业务开始
					// ------------------------------

					// 处理数据库逻辑
					// 注意交易单不要重复处理
					// 注意判断返回金额

					// ------------------------------
					// 处理业务完毕
					// ------------------------------
					return true;
				} else {
					// 错误时，返回结果未签名，记录retcode、retmsg看失败详情。
					System.out.println("查询验证签名失败或业务错误  ");
					System.out.println("retcode:"
							+ queryRes.getParameter("retcode") + " retmsg:"
							+ queryRes.getParameter("retmsg"));
					return false;
				}

			} else {

				System.out.println("后台调用通信失败");

				System.out.println(httpClient.getResponseCode());
				System.out.println(httpClient.getErrInfo());
				// 有可能因为网络原因，请求已经处理，但未收到应答。
				return false;
			}*/
		} else {
			System.out.println("通知签名验证失败");
			return false;
		}
		// return true;
	}

	/**
	 * 验证消息是否是支付宝发出的合法消息
	 * 
	 * @param params
	 *            通知返回来的参数数组
	 * @return 验证结果
	 */
	public static boolean verify_alipay(Map<String, String> params) {

		//判断交易状态trade_status
		String trade_status = params.get("trade_status");
		if(!trade_status.equals("TRADE_SUCCESS")){
			return false;
		}
/*		
		if(!trade_status.equals("TRADE_FINISHED")){
			return false;
		}
*/
		//
		
		// 判断responsetTxt是否为true，isSign是否为true
		// responsetTxt的结果不是true，与服务器设置问题、合作身份者ID、notify_id一分钟失效有关
		// isSign不是true，与安全校验码、请求时的参数格式（如：带自定义参数等）、编码格式有关
		String responseTxt = "true";
		if (params.get("notify_id") != null) {
			String notify_id = params.get("notify_id");
			responseTxt = verifyResponse(notify_id);
		}
		String sign = "";
		if (params.get("sign") != null) {
			sign = params.get("sign");
		}
		boolean isSign = getSignVeryfy(params, sign);

		// 写日志记录（若要调试，请取消下面两行注释）
		String sWord = "responseTxt=" + responseTxt + "\n isSign=" + isSign
				+ "\n 返回回来的参数：" + AlipayCore.createLinkString(params);
		System.out.println(sWord);
		// AlipayCore.logResult(sWord);

		if (isSign && responseTxt.equals("true")) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 根据反馈回来的信息，生成签名结果
	 * 
	 * @param Params
	 *            通知返回来的参数数组
	 * @param sign
	 *            比对的签名结果
	 * @return 生成的签名结果
	 */
	private static boolean getSignVeryfy(Map<String, String> Params, String sign) {
		// 过滤空值、sign与sign_type参数
		Map<String, String> sParaNew = AlipayCore.paraFilter(Params);
		// 获取待签名字符串
		String preSignStr = AlipayCore.createLinkString(sParaNew);
		// 获得签名验证结果
		boolean isSign = false;
		if (AlipayConfig.sign_type.equals("RSA")) {
			isSign = RSA.verify(preSignStr, sign, AlipayConfig.ali_public_key,
					AlipayConfig.input_charset);
		}
		return isSign;
	}

	/**
	 * 获取远程服务器ATN结果,验证返回URL
	 * 
	 * @param notify_id
	 *            通知校验ID
	 * @return 服务器ATN结果 验证结果集： invalid命令参数不对 出现这个错误，请检测返回处理中partner和key是否为空 true
	 *         返回正确信息 false 请检查防火墙或者是服务器阻止端口问题以及验证时间是否超过一分钟
	 */
	private static String verifyResponse(String notify_id) {
		// 获取远程服务器ATN结果，验证是否是支付宝服务器发来的请求

		String partner = AlipayConfig.getAliPartner();
		String veryfy_url = AlipayConfig.HTTPS_VERIFY_URL + "partner="
				+ partner + "&notify_id=" + notify_id;

		return checkUrl(veryfy_url);
	}

	/**
	 * 获取远程服务器ATN结果
	 * 
	 * @param urlvalue
	 *            指定URL路径地址
	 * @return 服务器ATN结果 验证结果集： invalid命令参数不对 出现这个错误，请检测返回处理中partner和key是否为空 true
	 *         返回正确信息 false 请检查防火墙或者是服务器阻止端口问题以及验证时间是否超过一分钟
	 */
	private static String checkUrl(String urlvalue) {
		String inputLine = "";

		try {
			URL url = new URL(urlvalue);
			HttpURLConnection urlConnection = (HttpURLConnection) url
					.openConnection();
			BufferedReader in = new BufferedReader(new InputStreamReader(
					urlConnection.getInputStream()));
			inputLine = in.readLine().toString();
		} catch (Exception e) {
			e.printStackTrace();
			inputLine = "";
		}

		return inputLine;
	}

}
